home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / nevow / loaders.py < prev    next >
Text File  |  2006-11-15  |  7KB  |  224 lines
  1. # Copyright (c) 2004 Divmod.
  2. # See LICENSE for details.
  3.  
  4. """Builtin template loaders that supply a Page or renderer with a
  5. document to render.
  6.  
  7. Nevow provides the following DocFactory loaders by default:
  8.  
  9.   - B{stan} - turn a stan tag tree into a DocFactory
  10.   - B{xmlfile} - load a well formed XML document from file
  11.   - B{htmlfile} - load a HTML file from disk
  12.   - B{xmlstr} - load a well formed XML document from a string
  13.   - B{htmlstr} - load a HTML document from a string
  14.  
  15. Unless absolutely necessary you should use either the stan loader or
  16. one of the xml loaders. The html loaders should only be used for badly
  17. formed HTML documents, i.e. if your HTML developer hasn't heard of
  18. XHTML yet. Even then, you should probably try to educate the HTML
  19. developer first ;-).
  20. """
  21.  
  22. import warnings
  23.  
  24. import os.path
  25. from zope.interface import implements
  26.  
  27. from twisted.python.reflect import getClass
  28. from twisted.web import microdom
  29.  
  30. from nevow import context
  31. from nevow import inevow
  32. from nevow import tags
  33. from nevow import flat
  34. from nevow.flat import flatsax
  35. from nevow.util import CachedFile
  36.  
  37.  
  38. class stan(object):
  39.     """A stan tags document factory"""
  40.  
  41.     implements(inevow.IDocFactory)
  42.  
  43.     stan = None
  44.     pattern = None
  45.     _cache = None
  46.  
  47.     def __init__(self, stan=None, pattern=None):
  48.         if stan is not None:
  49.             self.stan = stan
  50.         if pattern is not None:
  51.             self.pattern = pattern
  52.  
  53.  
  54.     def load(self, ctx=None, preprocessors=()):
  55.         if self._cache is None:
  56.             stan = [self.stan]
  57.             for proc in preprocessors:
  58.                 stan = proc(stan)
  59.             stan = flat.precompile(stan, ctx)
  60.             if self.pattern is not None:
  61.                 stan = inevow.IQ(stan).onePattern(self.pattern)
  62.             self._cache = stan
  63.         return self._cache
  64.  
  65.  
  66.  
  67. class htmlstr(object):
  68.     """A document factory for HTML contained in a string"""
  69.  
  70.     implements(inevow.IDocFactory)
  71.  
  72.     template = None
  73.     pattern = None
  74.     beExtremelyLenient = True
  75.     _cache = None
  76.  
  77.     def __init__(self, template=None, pattern=None, beExtremelyLenient=None):
  78.         warnings.warn(
  79.             "[v0.8] htmlstr is deprecated because it's buggy. Please start using xmlfile and/or xmlstr.",
  80.             DeprecationWarning,
  81.             stacklevel=2)
  82.         if template is not None:
  83.             self.template = template
  84.         if pattern is not None:
  85.             self.pattern = pattern
  86.         if beExtremelyLenient is not None:
  87.             self.beExtremelyLenient = beExtremelyLenient
  88.  
  89.     def load(self, ctx=None, preprocessors=()):
  90.         assert not preprocessors, "preprocessors not supported by htmlstr"
  91.         if self._cache is None:
  92.             doc = microdom.parseString(self.template, beExtremelyLenient=self.beExtremelyLenient)
  93.             doc = flat.precompile(doc, ctx)
  94.             if self.pattern is not None:
  95.                 doc = inevow.IQ(doc).onePattern(self.pattern)
  96.             self._cache = doc
  97.         return self._cache
  98.  
  99. class htmlfile(object):
  100.     """A document factory for an HTML disk template"""
  101.  
  102.     implements(inevow.IDocFactory)
  103.  
  104.     template = None
  105.     pattern = None
  106.     templateDir = ''
  107.     beExtremelyLenient = True
  108.  
  109.     def __init__(self, template=None, pattern=None, templateDir=None, beExtremelyLenient=None):
  110.         warnings.warn(
  111.             "[v0.8] htmlfile is deprecated because it's buggy. Please start using xmlfile and/or xmlstr.",
  112.             DeprecationWarning,
  113.             stacklevel=2)
  114.         if template is not None:
  115.             self.template = template
  116.         if pattern is not None:
  117.             self.pattern = pattern
  118.         if templateDir is not None:
  119.             self.templateDir = templateDir
  120.         if beExtremelyLenient is not None:
  121.             self.beExtremelyLenient = beExtremelyLenient
  122.         _filename = os.path.join(self.templateDir, self.template)
  123.         self._cache = CachedFile(_filename, self._reallyLoad)
  124.  
  125.     def _reallyLoad(self, path, ctx):
  126.         doc = microdom.parse(path, beExtremelyLenient=self.beExtremelyLenient)
  127.         doc = flat.precompile(doc, ctx)
  128.         if self.pattern is not None:
  129.             doc = inevow.IQ(doc).onePattern(self.pattern)
  130.         return doc
  131.  
  132.     def load(self, ctx=None, preprocessors=()):
  133.         assert not preprocessors, "preprocessors not supported by htmlfile"
  134.         return self._cache.load(ctx)
  135.  
  136. class xmlstr(object):
  137.  
  138.     implements(inevow.IDocFactory)
  139.  
  140.     template = None
  141.     pattern = None
  142.     ignoreDocType = None
  143.     ignoreComment = None
  144.     _cache = None
  145.  
  146.     def __init__(self, template=None, pattern=None, ignoreDocType=False, ignoreComment=False):
  147.         if template is not None:
  148.             self.template = template
  149.         if pattern is not None:
  150.             self.pattern = pattern
  151.         if ignoreDocType is not None:
  152.             self.ignoreDocType = ignoreDocType
  153.         if ignoreComment is not None:
  154.             self.ignoreComment = ignoreComment
  155.  
  156.     def load(self, ctx=None, preprocessors=()):
  157.         """
  158.         Get an instance, possibly cached from a previous call, of this document
  159.         """
  160.         if self._cache is None:
  161.             doc = flatsax.parseString(self.template, self.ignoreDocType, self.ignoreComment)
  162.             for proc in preprocessors:
  163.                 doc = proc(doc)
  164.             doc = flat.precompile(doc, ctx)
  165.             if self.pattern is not None:
  166.                 doc = inevow.IQ(doc).onePattern(self.pattern)
  167.             self._cache = doc
  168.         return self._cache
  169.  
  170.  
  171. class xmlfile(object):
  172.  
  173.     implements(inevow.IDocFactory)
  174.  
  175.     template = None
  176.     templateDir = None
  177.     pattern = None
  178.     ignoreDocType = False
  179.     ignoreComment = False
  180.  
  181.     def __init__(self, template=None, pattern=None, templateDir=None, ignoreDocType=None, ignoreComment=None):
  182.         self._cache = {}
  183.         if template is not None:
  184.             self.template = template
  185.         if pattern is not None:
  186.             self.pattern = pattern
  187.         if templateDir is not None:
  188.             self.templateDir = templateDir
  189.         if ignoreDocType is not None:
  190.             self.ignoreDocType = ignoreDocType
  191.         if ignoreComment is not None:
  192.             self.ignoreComment = ignoreComment
  193.         if self.templateDir is not None:
  194.             self._filename = os.path.join(self.templateDir, self.template)
  195.         else:
  196.             self._filename = self.template
  197.  
  198.         self._cache = {}
  199.  
  200.     def load(self, ctx=None, preprocessors=()):
  201.         rendererFactoryClass = None
  202.         if ctx is not None:
  203.             r = inevow.IRendererFactory(ctx, None)
  204.             if r is not None:
  205.                 rendererFactoryClass = getClass(r)
  206.  
  207.         cacheKey = (self._filename, self.pattern, rendererFactoryClass)
  208.         cachedFile = self._cache.get(cacheKey)
  209.         if cachedFile is None:
  210.             cachedFile = self._cache[cacheKey] = CachedFile(self._filename, self._reallyLoad)
  211.  
  212.         return cachedFile.load(ctx, preprocessors)
  213.  
  214.     def _reallyLoad(self, path, ctx, preprocessors):
  215.         doc = flatsax.parse(open(self._filename), self.ignoreDocType, self.ignoreComment)
  216.         for proc in preprocessors:
  217.             doc = proc(doc)
  218.         doc = flat.precompile(doc, ctx)
  219.  
  220.         if self.pattern is not None:
  221.             doc = inevow.IQ(doc).onePattern(self.pattern)
  222.  
  223.         return doc
  224.